import { QueueInterface } from './queue-interface';

/**
 * 自定义队列示例
 * 实现了QueueInterface接口的简单队列
 */
export class CustomQueue extends QueueInterface {
  constructor() {
    super();
    this.tasks = [];
    this.callbacks = [];
    this.locked = false;
    this.processing = false;
  }
  
  /**
   * 添加任务到队列
   * @param {Function} task 任务函数
   * @param {Object} params 任务参数
   * @param {Object} hooks 钩子函数
   * @returns {Promise} Promise对象
   */
  addTask(task, params, hooks) {
    return new Promise((resolve, reject) => {
      this.tasks.push({
        task,
        params,
        hooks,
        resolve,
        reject
      });
      
      console.log('[CustomQueue] 添加了新任务，当前队列长度:', this.tasks.length);
    });
  }
  
  /**
   * 检查队列是否为空
   * @returns {boolean} 队列是否为空
   */
  isEmpty() {
    return this.tasks.length === 0;
  }
  
  /**
   * 获取队列大小
   * @returns {number} 队列大小
   */
  size() {
    return this.tasks.length;
  }
  
  /**
   * 开始执行队列
   */
  start() {
    if (this.processing || this.isEmpty()) {
      return;
    }
    
    this.processing = true;
    this.processNext();
  }
  
  /**
   * 处理下一个任务
   * @private
   */
  processNext() {
    if (this.isEmpty()) {
      this.processing = false;
      this.locked = false;
      
      // 触发完成回调
      this.callbacks.forEach(callback => {
        try {
          callback();
        } catch (e) {
          console.error('[CustomQueue] 回调执行错误:', e);
        }
      });
      
      return;
    }
    
    const { task, params, hooks, resolve, reject } = this.tasks.shift();
    
    // 执行任务前的钩子
    if (hooks && typeof hooks.beforeStart === 'function') {
      hooks.beforeStart({ task, params });
    }
    
    // 执行任务
    try {
      Promise.resolve(task(params))
        .then(result => {
          // 执行任务后的钩子
          if (hooks && typeof hooks.beforeEnd === 'function') {
            hooks.beforeEnd({ task, params, result });
          }
          
          // 解析Promise
          resolve(result);
          
          // 处理下一个任务
          setTimeout(() => this.processNext(), 0);
        })
        .catch(error => {
          // 执行错误钩子
          if (hooks && typeof hooks.onError === 'function') {
            hooks.onError({ task, params, error });
          }
          
          // 拒绝Promise
          reject(error);
          
          // 处理下一个任务
          setTimeout(() => this.processNext(), 0);
        });
    } catch (e) {
      // 执行错误钩子
      if (hooks && typeof hooks.onError === 'function') {
        hooks.onError({ task, params, error: e });
      }
      
      // 拒绝Promise
      reject(e);
      
      // 处理下一个任务
      setTimeout(() => this.processNext(), 0);
    }
  }
  
  /**
   * 锁定队列
   */
  lock() {
    this.locked = true;
  }
  
  /**
   * 添加队列执行完成后的回调
   * @param {Function} callback 回调函数
   */
  then(callback) {
    if (typeof callback === 'function') {
      this.callbacks.push(callback);
    }
  }
}

/**
 * 创建自定义队列示例
 * @returns {QueueInterface} 自定义队列实例
 */
export function createCustomQueue() {
  return new CustomQueue();
}

export default CustomQueue; 